package writtenTraining.day23;

import java.util.*;


/**
 * day23:(1)模拟：打怪
 */
 class Main1 {
    public static void main(String[] args) {
//         模拟

        // 输入数据
        Scanner in =new  Scanner(System.in);
        int k = in.nextInt();

        while(k-- > 0) {
            int h = in.nextInt(),a = in.nextInt();
            int H = in.nextInt(), A = in.nextInt();
            //        特判： 如果怪物无攻击
            if(A <= 0 || a >= H) {
                System.out.println(-1);
            } else {
                int ret = 0;
                // 循环模拟
                while(true) {
                    int tmpH = H;
                    while(true) {
                        tmpH -= a;
//                 一旦怪物的血量低于 0 就停止进攻
                        if(tmpH <= 0) {
                            break;
                        }
                        h -= A;
                        if(h <= 0) {
                            break;
                        }
                    }

//             如果自身的血量低于0 就游戏结束
                    if(h <= 0) {
                        break;
                    }

//             否则就结果加一
                    ret++;
                }

//         输出结果
                System.out.println(ret);
            }
        }

    }
}

/**
 *
 * day23(2):哈希 + 排序 + 集合 :[编程题]字符串分类
 *
 */
public class Main {
    public static void main(String[] args) {
        // 哈希 + 排序 + 集合 

        // 输入数据
        Scanner in =  new Scanner(System.in);
        int n = in.nextInt();

        Set<String> set =new HashSet<>();

        // 枚举每一个字符串
        for(int i =0; i < n; i++) {
            String str = in.next();
            int len = str.length();
            int[] hash = new int[26];
            // 哈希统计
            for(int j = 0; j < len; j++) {
                hash[str.charAt(j) - 'a']++;
            }
            
            StringBuilder s = new StringBuilder();
            // 排序拼接
            for(int j = 0; j < 26; j++) {
                while(hash[j] > 0) {
                    s.append((char)(j + 'a'));
                    hash[j]--;
                }
            }

            set.add(s.toString());
        }

        // 输入个数
        System.out.println(set.size());
    }
}


/**
 * day23:(3)dfs：NC345 城市群数量
 */


class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param m int整型ArrayList<ArrayList<>>
     * @return int整型
     */
    int n;
    boolean[] city;
    public int citys (ArrayList<ArrayList<Integer>> m) {
        // 深度优先遍历 dfs
        // 准备工作
        n = m.size();
        city = new boolean[n];
        int ret = 0;
        // 从每一个位置开始找， 只要未出现过的城市群就ret++
        for(int i =0; i < n ; i++) {
            if(!city[i]) {
                dfs(m,i);
                ret++;
            }
        }


        return ret;
    }

    private void dfs(ArrayList<ArrayList<Integer>> m , int x) {
        // 标记该城市已经找过
        city[x] = true;

        // 探查下一个城市群是否出现过
        for(int k =0; k < n; k++) {
            // 如果该城市没有搜索过，
            // 并且为 1 就继续深搜
            if(!city[k] && m.get(x).get(k) == 1) {
                dfs(m,k);
            }
        }
    }
}